package basic;

import java.util.concurrent.atomic.AtomicInteger;

// 测试 volatile
public class VolatileTest {
    // 未使用volatile修饰且非原子操作的共享变量
    private static int nonVolatileCount = 0;
    // 使用volatile修饰但非原子操作的共享变量
    private static volatile int volatileCount = 0;
    // 使用AtomicInteger实现原子性自增操作的共享变量
    private static AtomicInteger atomicCount = new AtomicInteger(0);

    private static volatile String ii;


    public static void main(String[] args) throws InterruptedException {
        // 创建多个线程，这里创建10个线程，可根据需要调整
        int numThreads = 10;
        Thread[] nonVolatileThreads = new Thread[numThreads];
        Thread[] volatileThreads = new Thread[numThreads];
        Thread[] atomicThreads = new Thread[numThreads];

        // 分别启动多个线程对三个共享变量进行自增操作
        for (int i = 0; i < numThreads; i++) {
            nonVolatileThreads[i] = new Thread(() -> {
                for (int j = 0; j < 100000; j++) {
                    nonVolatileCount++;
                }
            });

            volatileThreads[i] = new Thread(() -> {
                for (int j = 0; j < 100000; j++) {
                    volatileCount++;
                }
            });

            atomicThreads[i] = new Thread(() -> {
                for (int j = 0; j < 100000; j++) {
                    atomicCount.incrementAndGet();
                }
            });

            nonVolatileThreads[i].start();
            volatileThreads[i].start();
            atomicThreads[i].start();
        }

        // 等待所有线程执行完成
        for (int i = 0; i < numThreads; i++) {
            nonVolatileThreads[i].join();
            volatileThreads[i].join();
            atomicThreads[i].join();
        }

        // 输出三个共享变量最终的值
        System.out.println("未使用volatile修饰且非原子操作的变量最终值：" + nonVolatileCount);
        System.out.println("使用volatile修饰但非原子操作的变量最终值：" + volatileCount);
        System.out.println("使用AtomicInteger实现原子性自增操作的变量最终值：" + atomicCount.get());
    }
}
